import axios from "axios";
import router from "@/router";
import { useTokenStore } from "@/stores/useTokenStore";
import { ElMessage } from "element-plus";

// 创建axios实例
const instance = axios.create({
    baseURL: '/api',
    timeout: 10000 // 10秒超时
});

// 是否正在刷新token的标记
let isRefreshing = false;
// 重试队列，每一项将是一个待执行的函数形式
let requests = [];

// 响应拦截器
instance.interceptors.response.use(result => {
    if (result.data.code === 200) {
        return result.data;
    }
    if (result.config.responseType === 'blob') {
        return result.data; // 返回原始数据
    }
    ElMessage.error(result.data.msg ? result.data.msg : '服务器内部异常');
    return Promise.reject(result.data);
}, async error => {
    if (error.response && error.response.status === 401) {
        const tokenStore = useTokenStore();
        const config = error.config;

        // 如果没有token，直接跳转登录页
        if (!tokenStore.token) {
            ElMessage.error('请先登录');
            router.push('/login');
            return Promise.reject(error);
        }

        // 避免重复刷新
        if (!isRefreshing) {
            isRefreshing = true;

            try {
                // 创建一个新的axios实例来刷新token，避免循环调用拦截器
                const refreshResponse = await axios({
                    method: 'post',
                    url: '/api/auth/refresh',
                    headers: {
                        'Authorization': tokenStore.token
                    }
                });

                if (refreshResponse.data.code === 200) {
                    const newToken = refreshResponse.data.data;
                    // 更新token
                    tokenStore.setToken(newToken);
                    config.headers.Authorization = newToken;

                    // 执行队列中的请求
                    requests.forEach(cb => cb(newToken));
                    requests = [];

                    // 重新发起请求
                    return instance(config);
                } else {
                    // 刷新失败，清除token并跳转到登录页
                    tokenStore.clearToken();
                    ElMessage.error('登录已过期，请重新登录');
                    router.push('/login');
                    return Promise.reject(error);
                }
            } catch (err) {
                console.error('Token刷新失败', err);
                // 刷新失败，清除token并跳转到登录页
                tokenStore.clearToken();
                ElMessage.error('登录已过期，请重新登录');
                router.push('/login');
                return Promise.reject(error);
            } finally {
                isRefreshing = false;
            }
        } else {
            // 返回一个promise，等待刷新token完成后再重试
            return new Promise(resolve => {
                requests.push(token => {
                    config.headers.Authorization = token;
                    resolve(instance(config));
                });
            });
        }
    } else {
        // 其他错误
        const errorMsg = error.response?.data?.msg || '请求失败';
        ElMessage.error(errorMsg);
        return Promise.reject(error);
    }
});

// 请求拦截器
instance.interceptors.request.use((config) => {
    const tokenStore = useTokenStore();
    const token = tokenStore.token;
    console.log('发送请求:', config.url, '是否有token:', !!token, token ? `(${token.substring(0, 15)}...)` : '');

    if (token) {
        // 确保Authorization头正确设置
        config.headers = config.headers || {};
        config.headers['Authorization'] = token;
        console.log('请求头已设置Authorization');
    } else {
        console.warn('请求无token');
    }
    return config;
}, (err) => {
    console.error('请求错误:', err);
    return Promise.reject(err);
});

export default instance;